package org.stvd.common.utils;
 
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Collection;
import java.util.Map;
import java.util.Random;
 
import org.stvd.core.jdbc.sequence.SequenceUtil;
import org.stvd.core.util.DateUtil;
 
/**
 * 字符串工具类
 * @author houzx
 */
public class StringsUtil {
    
    /** 空*/
    public static final String EMPTY = "";
    
    /** 空字符串 */
    private static final String NULLSTR = "";
 
    /** 下划线 */
    private static final char SEPARATOR = '_';
    
    /**
     * 生成随机码
     * @param count 要生成的随机码的位数
     * @param type 要生成的随机码的类型：0-英文数字混合；1-纯英文；2-纯数字
     * @return
     */
    public static String getRandomCode(int count, String type) {
        String val = "";
        Random random = new Random();
        for (; val.length()<count;) {
            //输出字母还是数字
            String charOrNum = (random.nextInt(2)%2==0) ? "char" : "num";
            if ((type.equals("0") || type.equals("1"))
                    && "char".equalsIgnoreCase(charOrNum)) {
                //字符串
                int choice = random.nextInt(2) % 2 == 0 ? 65 : 97;
                //取得大写字母还是小写字母
                val += (char) (choice+random.nextInt(26));
            } else if ((type.equals("0") || type.equals("2"))
                    && "num".equalsIgnoreCase(charOrNum)) {
                // 数字
                val += String.valueOf(random.nextInt(10));
            }
        }
        return val;
    }
    
    /**
     * 获取文章编号， 例如： '100000'+'000001'
     * @param idPrefix
     * @return
     */
    public static String getArticleId(String idPrefix) {
        String keyName = "ACNO" + idPrefix;
        return SequenceUtil.getInstance().getId(keyName, idPrefix, 6);
    }
    
    /**
     * 获取订单编号， 例如： '20190412'+'000001'
     * @param idPrefix
     * @return
     */
    public static String getOrderNo() {
        String ymd = DateUtil.getSystemDateOfY2D();
        String keyName = "ORDERNO" + ymd;
        return SequenceUtil.getInstance().getId(keyName, ymd, 6);
    }
    
    /**
     * 获取部门编号
     * @param compId 企业ID
      * @param prefix 编号前缀
     * @return
     */
    public static String getDpetSn(Long compId, String prefix) {
        String keyName = compId.toString();
        return SequenceUtil.getInstance().getId(keyName, prefix, 3);
    }
    
     /**
      * md5 加密字符串
      * @param String 加要密的字符串
      * @return String 加密后的字符串
      * @throws NoSuchAlgorithmException 
      */
      public static final String md5(String input){
         byte[] inputByte=input.getBytes();
         MessageDigest md = null;
         try {
              md = MessageDigest.getInstance("md5");
         } catch (NoSuchAlgorithmException e) {
              e.printStackTrace();
         }
         md.update(inputByte);
         byte[] digest=md.digest();
         StringBuffer buf=new StringBuffer();
         for(int i=0;i<digest.length;i++){
          int val=((int)digest[i]) & 0xff;
          if(val < 16){
           buf.append("0");
          }
          buf.append(Integer.toHexString(val));
         }
         return buf.toString().toLowerCase();
      }
      
      /**
       * 获取参数不为空值
       * @param value defaultValue 要判断的value
       * @return value 返回值
       */
      public static <T> T nvl(T value, T defaultValue) {
          return value != null ? value : defaultValue;
      }
 
      /**
       * 判断一个Collection是否为空， 包含List，Set，Queue
       * @param coll 要判断的Collection
       * @return true：为空 false：非空
       */
      public static boolean isEmpty(Collection<?> coll) {
          return isNull(coll) || coll.isEmpty();
      }
 
      /**
       * 判断一个Collection是否非空，包含List，Set，Queue
       * @param coll 要判断的Collection
       * @return true：非空 false：空
       */
      public static boolean isNotEmpty(Collection<?> coll){
          return !isEmpty(coll);
      }
 
      /**
       * 判断一个对象数组是否为空
       * @param objects 要判断的对象数组
       ** @return true：为空 false：非空
       */
      public static boolean isEmpty(Object[] objects){
          return isNull(objects) || (objects.length == 0);
      }
 
      /**
       * 判断一个对象数组是否非空
       * @param objects 要判断的对象数组
       * @return true：非空 false：空
       */
      public static boolean isNotEmpty(Object[] objects){
          return !isEmpty(objects);
      }
 
      /**
       * 判断一个Map是否为空
       * @param map 要判断的Map
       * @return true：为空 false：非空
       */
      public static boolean isEmpty(Map<?, ?> map)  {
          return isNull(map) || map.isEmpty();
      }
 
      /**
       * 判断一个Map是否为空
       * @param map 要判断的Map
       * @return true：非空 false：空
       */
      public static boolean isNotEmpty(Map<?, ?> map) {
          return !isEmpty(map);
      }
 
      /**
       * 判断一个字符串是否为空串
       * @param str String
       * @return true：为空 false：非空
       */
      public static boolean isEmpty(String str) {
          return isNull(str) || NULLSTR.equals(str.trim());
      }
 
      /**
       * 判断一个字符串是否为非空串
       * @param str String
       * @return true：非空串 false：空串
       */
      public static boolean isNotEmpty(String str){
          return !isEmpty(str);
      }
      
      /**
       * 判断一个对象是否为空
       * @param object Object
       * @return true：为空 false：非空
       */
      public static boolean isNull(Object object) {
          return object == null;
      }
 
      /**
       * 判断一个对象是否非空
       * @param object Object
       * @return true：非空 false：空
       */
      public static boolean isNotNull(Object object){
          return !isNull(object);
      }
 
      /**
       * 判断一个对象是否是数组类型（Java基本型别的数组）
       * @param object 对象
       * @return true：是数组 false：不是数组
       */
      public static boolean isArray(Object object) {
          return isNotNull(object) && object.getClass().isArray();
      }
 
      /**
       * 去空格
       */
      public static String trim(String str) {
          return (str == null ? "" : str.trim());
      }
      
      /**
     * 是否包含字符串
     * @param str 验证字符串
     * @param strs 字符串组
     * @return 包含返回true
     */
    public static boolean inStringIgnoreCase(String str, String... strs) {
         if (str != null && strs != null) {
            for (String s : strs) {
                if (str.equalsIgnoreCase(trim(s))){
                    return true;
                }
            }
        }
        return false;
    }
 
    /**
     * 截取字符串
     * @param str 字符串
     * @param start 开始
     * @return 结果
     */
    public static String substring(final String str, int start) {
        if (str == null){
            return NULLSTR;
        }
        if (start < 0){
            start = str.length() + start;
        }
        if (start < 0){
            start = 0;
        }
        if (start > str.length()){
            return NULLSTR;
        }
        return str.substring(start);
    }
 
    /**
     * 截取字符串
     * @param str 字符串
     * @param start 开始
     * @param end 结束
     * @return 结果
     */
    public static String substring(final String str, int start, int end){
        if (str == null) {
            return NULLSTR;
        }
        if (end < 0){
            end = str.length() + end;
        }
        if (start < 0){
            start = str.length() + start;
        }
        if (end > str.length()) {
            end = str.length();
        }
        if (start > end){
            return NULLSTR;
        }
        if (start < 0){
            start = 0;
        }
        if (end < 0){
            end = 0;
        }
        return str.substring(start, end);
    }
    
    /**
     * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
     * @param name 转换前的下划线大写方式命名的字符串
     * @return 转换后的驼峰式命名的字符串
     */
    public static String convertToCamelCase(String name) {
        StringBuilder result = new StringBuilder();
        // 快速检查
        if (name == null || name.isEmpty()) {
            // 没必要转换
            return "";
        } else if (!name.contains("_")) {
            // 不含下划线，仅将首字母大写
            return name.substring(0, 1).toUpperCase() + name.substring(1);
        }
        // 用下划线将原始字符串分割
        String[] camels = name.split("_");
        for (String camel : camels) {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty()) {
                continue;
            }
            // 首字母大写
            result.append(camel.substring(0, 1).toUpperCase());
            result.append(camel.substring(1).toLowerCase());
        }
        return result.toString();
    }
 
    /**
     * 驼峰式命名法 例如：user_name->userName
     */
    public static String toCamelCase(String s) {
        if (s == null) {
            return null;
        }
        s = s.toLowerCase();
        StringBuilder sb = new StringBuilder(s.length());
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == SEPARATOR) {
                upperCase = true;
            } else if (upperCase) {
                sb.append(Character.toUpperCase(c));
                upperCase = false;
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }
    /**
	 * 将字符串按“,”拆分成字符串数组
	 * 
	 * @param sourceStr
	 *            要拆分的字符串
	 * @return
	 */
	public String[] splitStr(String sourceStr) {
		if (sourceStr != null && !"".equals(sourceStr)) {
			return sourceStr.split(",");
		} else {
			return null;
		}
	}

	public String addStr(String[] array) {
		if (array != null) {
			String result = "('";
			for (int i = 0; i < array.length; i++) {
				result = result + array[i] + ",";
			}
			result = result + "')";
			return result;
		} else {
			return null;
		}
	}
}
